package com.kehutong.contact.util;

import org.coraframework.util.Objects;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.util.*;

/**
 * 基于Java8线程安全的时间工具类
 *
 * @author jian Ye
 * @date: 2021-08-27
 */
public class DateUtil {

    /*** 例如:2021 */
    public static final String YEAR = "yyyy";
    /*** 例如:2021-08 */
    public static final String YEAR_MONTH = "yyyy-MM";
    /*** 例如:2021-08-28 */
    public static final String YEAR_MONTH_DAY = "yyyy-MM-dd";
    /*** 例如:2021-08-28 10 */
    public static final String YEAR_MONTH_DAY_HOUR = "yyyy-MM-dd HH";
    /*** 例如:2021-08-28 10:00 */
    public static final String YEAR_MONTH_DAY_HOUR_MINUTE = "yyyy-MM-dd HH:mm";
    /*** 例如:2021-08-28 10:00:00 */
    public static final String YEAR_MONTH_DAY_HOUR_MINUTE_SECONDS = "yyyy-MM-dd HH:mm:ss";
    /*** 例如:2021-08-28 10:00:00.0 */
    public static final String YEAR_MONTH_DAY_HOUR_MINUTE_SECONDS_X = "yyyy-MM-dd HH:mm:ss.S";
    /*** 例如:2021/08/28 10:00:00 */
    public static final String SLASH = "yyyy/MM/dd HH:mm:ss";
    /*** 例如:202108281000001234 */
    public static final String TIME_WITH_MILLS = "yyyyMMddHHmmssSSS";
    /*** 例如:20210828100000 */
    public static final String TIME_WITH_SECOND = "yyyyMMddHHmmss";
    /*** 例如:10:00 */
    public static final String TIME_WITHOUT_SECOND = "HH:mm";
    /*** 例如:yyyy-MM-dd 00:00:00*/
    public static final String YEAR_MONTH_DAY_000000 = "yyyy-MM-dd 00:00:00";
    /*** 例如:yyyy-MM-dd 23:59:59*/
    public static final String YEAR_MONTH_DAY_235959 = "yyyy-MM-dd 23:59:59";





    /**
     * 获取当前格式化的时间
     *
     * @param formatStr 时间格式化（如：yyyy-MM-dd）
     * @return 返回格式化后的时间
     */
    public static String getTime(String formatStr) {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(formatStr));
    }

    /**
     * 返回当前的日期
     *
     * @return 如：2021-08-27
     */
    public static LocalDate getCurrentLocalDate() {
        return LocalDate.now();
    }

    /**
     * 返回当前日期时间
     *
     * @return 如：2021-08-27T17:37:46.518
     */
    public static LocalDateTime getCurrentLocalDateTime() {
        return LocalDateTime.now();
    }


    /**
     * 自定义格式化Date日期为字符串
     *
     * @param date    date时间
     * @param pattern 自定义格式 (如:yyyy-MM-dd HH:mm:ss)
     * @return 日期字符串
     */
    public static String format(Date date, String pattern) {
        Instant instant = date.toInstant();
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
        return localDateTime.format(DateTimeFormatter.ofPattern(pattern, Locale.CHINA));
    }

    /**
     * 格式化Date日期为字符串
     *
     * @param date date
     * @return 日期字符串（如：2021-08-27 15:10:10）
     */
    public static String format(Date date) {
        Instant instant = date.toInstant();
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
        return localDateTime.format(DateTimeFormatter.ofPattern(YEAR_MONTH_DAY_HOUR_MINUTE_SECONDS, Locale.CHINA));
    }


    /**
     * 解析字符串日期为 Date日期
     *
     * @param dateStr 日期字符串
     * @param pattern 参数1的格式 (如:yyyy-MM-dd HH:mm:ss)
     * @return Date格式化后的时间
     */
    public static Date parse(String dateStr, String pattern) {
        Instant instant;
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern, Locale.CHINA);
        try {
            LocalDateTime localDateTime = LocalDateTime.parse(dateStr, formatter);
            instant = localDateTime.atZone(ZoneId.systemDefault()).toInstant();
        } catch (DateTimeParseException e) {
            LocalDate localDate = LocalDate.parse(dateStr, formatter);
            instant = localDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
        }
        return Date.from(instant);
    }


    /**
     * 获取该日期的23:00:00，或者前一天的23:00:00
     *
     * @param date       Date时间
     * @param isPrevious true=表示获取前一天的；false=表示当前日期的
     * @return 返回date（Sun Aug 29 23:00:00 CST 2021）
     */
    public static Date getBizTime(Date date, boolean isPrevious) {
        LocalDateTime dateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        if (isPrevious) {
            dateTime = dateTime.minusDays(1);
        }
        return localDateTime2Date(dateTime.withHour(23).withMinute(0).withSecond(0));
    }

    /**
     * 获取该日期的23:00:00，或者前一天的23:00:00
     *
     * @param dateStr    yyyy-MM-dd格式的日期
     * @param isPrevious true=表示获取前一天的, false=表示当前日期的
     * @return 返回date（Sun Aug 29 23:00:00 CST 2021）
     */
    public static Date getBizTime(String dateStr, boolean isPrevious) {
        LocalDate date = LocalDate.parse(dateStr, DateTimeFormatter.ofPattern(YEAR_MONTH_DAY, Locale.CHINA));
        if (isPrevious) {
            date = date.minusDays(1);
        }
        return localDateTime2Date(date.atTime(23, 0, 0));
    }


    /**
     * 获取当前年份
     *
     * @return 返回年份（如：2021）
     */
    public static int getYear() {
        LocalDateTime localTime = LocalDateTime.now();
        return localTime.get(ChronoField.YEAR);
    }

    /**
     * 获取昨天的年份
     *
     * @return 返回年份（如：2021）
     */
    public static int getYesterdayYear() {
        LocalDateTime localTime = LocalDateTime.now();
        LocalDateTime localDateTime = localTime.plusDays(-1);
        return localDateTime.get(ChronoField.YEAR);
    }


    /**
     * 获取当前月份
     *
     * @return 返回月份（如：8）
     */
    public static int getMonth() {
        LocalDateTime localTime = LocalDateTime.now();
        return localTime.get(ChronoField.MONTH_OF_YEAR);
    }

    /**
     * 获取昨天的月份
     *
     * @return 返回月份（如：8）
     */
    public static int getYesterdayMonth() {
        LocalDateTime localTime = LocalDateTime.now();
        LocalDateTime localDateTime = localTime.plusDays(-1);
        return localDateTime.get(ChronoField.MONTH_OF_YEAR);
    }


    /**
     * 获取当前是某月的第几天
     *
     * @return 返回几号（如：27）
     */
    public static int getMonthOfDay() {
        LocalDateTime localTime = LocalDateTime.now();
        return localTime.get(ChronoField.DAY_OF_MONTH);
    }

    /**
     * 获取昨天 是某月的第几天
     *
     * @return 返回几号（如：27）
     */
    public static int getYesterdayMonthOfDay() {
        LocalDateTime localTime = LocalDateTime.now();
        LocalDateTime localDateTime = localTime.plusDays(-1);
        return localDateTime.get(ChronoField.DAY_OF_MONTH);
    }


    /**
     * LocalDateTime类型转为Date
     *
     * @param localDateTime LocalDateTime object
     * @return Date object
     */
    public static Date localDateTime2Date(LocalDateTime localDateTime) {
        return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 将LocalDate类型转为Date
     *
     * @param localDate LocalDate object
     * @return Date object
     */
    public static Date localDate2Date(LocalDate localDate) {

        ZonedDateTime zonedDateTime = localDate.atStartOfDay(ZoneId.systemDefault());

        return Date.from(zonedDateTime.toInstant());
    }

    /**
     * 将Date类型转为LocalDate
     */
    public static LocalDate dateToLocalDate(Date date) {
        return Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDate();
    }

    /**
     * 将Date类型转为LocalDateTime
     */
    public static LocalDateTime dateToLocalDateTime(Date date) {
        return Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDateTime();
    }

    /**
     * 时间运算,减传负数（分钟）
     *
     * @param date        日期
     * @param plusMinutes 要加减的分钟数 如减（-5）
     * @return 新的日期
     */
    public static Date addMinutes(Date date, Long plusMinutes) {
        LocalDateTime dateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        LocalDateTime newDateTime = dateTime.plusMinutes(plusMinutes);
        return Date.from(newDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 时间运算,减传负数（小时）
     *
     * @param date date
     * @param hour 要加减的小时数 如减（-6）
     * @return new date
     */
    public static Date addHour(Date date, Long hour) {
        LocalDateTime dateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        LocalDateTime localDateTime = dateTime.plusHours(hour);
        return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 时间运算,减传负数（天数）
     *
     * @param date date
     * @param days 要加减的天数 如减（-7）
     * @return new date
     */
    public static Date addDays(Date date, Long days) {
        LocalDateTime dateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        LocalDateTime localDateDays = dateTime.plusDays(days);
        return Date.from(localDateDays.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 时间运算,减传负数（周数）
     *
     * @param date  date
     * @param weeks 要加减的周数
     * @return new date
     */
    public static Date addWeeks(Date date, Long weeks) {
        LocalDateTime dateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        LocalDateTime localDateWeeks = dateTime.plusWeeks(weeks);
        return Date.from(localDateWeeks.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 时间运算,减传负数（月数）
     *
     * @param date   date
     * @param months 要加减的月数
     * @return new date
     */
    public static Date addMonths(Date date, Long months) {
        LocalDateTime dateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        LocalDateTime localDateMonths = dateTime.plusMonths(months);
        return Date.from(localDateMonths.atZone(ZoneId.systemDefault()).toInstant());
    }


    /**
     * 时间运算,减传负数（年数）
     *
     * @param date  date
     * @param years 要加减的年数
     * @return new date
     */
    public static Date addYears(Date date, Long years) {
        LocalDateTime dateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        LocalDateTime localDateYears = dateTime.plusYears(years);
        return Date.from(localDateYears.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * @return 返回当天的起始时间
     */
    public static Date getStartTime() {
        LocalDateTime now = LocalDateTime.now().withHour(0).withMinute(0).withSecond(0);
        return localDateTime2Date(now);
    }

    /**
     * @return 返回某天的起始时间00:00:00
     */
    public static Date getStartTimeWithMills(Date date) {
        LocalDateTime dateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        dateTime = dateTime.withHour(0).withMinute(0).withSecond(0);
        return localDateTime2Date(dateTime);
    }

    /**
     * @return 返回当天的结束时间
     */
    public static Date getEndTime() {
        LocalDateTime now = LocalDateTime.now().withHour(23).withMinute(59).withSecond(59).withNano(999);
        return localDateTime2Date(now);
    }

    /**
     * @param date 某天
     * @return 返回某天的结束时间23:59:59
     */
    public static Date getEndTimeWithMills(Date date) {
        LocalDateTime dateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        dateTime = dateTime.withHour(23).withMinute(59).withSecond(59);
        return localDateTime2Date(dateTime);
    }

    /**
     * @param date 某天
     * @return 返回某天的结束时间23:00:00
     */
    public static Date getDateTimeWithMills(Date date) {
        LocalDateTime dateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        dateTime = dateTime.withHour(23).withMinute(00).withSecond(00);
        return localDateTime2Date(dateTime);
    }



    /**
     * 当前时间减月份
     *
     * @param monthsToSubtract 月份
     * @return Date
     */
    public static Date minusMonths(long monthsToSubtract) {
        LocalDate localDate = LocalDate.now().minusMonths(monthsToSubtract);
        return localDate2Date(localDate);
    }

    /**
     * 查询当前年的第一天
     * 默认格式yyyy-MM-dd
     *
     * @return String
     */
    public static String getFirstDayOfCurrentYear() {
        LocalDateTime localDateTime = LocalDateTime.now().withMonth(1).withDayOfMonth(1);
        return format(localDateTime2Date(localDateTime), YEAR_MONTH_DAY);
    }

    /**
     * 查询当前年的第一天
     *
     * @param pattern 格式
     * @return String
     */
    public static String getFirstDayOfCurrentYear(String pattern) {
        LocalDateTime localDateTime = LocalDateTime.now().withMonth(1).withDayOfMonth(1);
        return format(localDateTime2Date(localDateTime), pattern);
    }

    /**
     * 查询前一年最后一个月第一天
     *
     * @return 默认格式yyyy-MM-dd
     */
    public static String getLastMonthFirstDayOfPreviousYear() {
        LocalDateTime localDateTime = LocalDateTime.now().minusYears(1L).withMonth(12).withDayOfMonth(1);
        return format(localDateTime2Date(localDateTime), YEAR_MONTH_DAY);
    }

    /**
     * 查询前一年最后一个月第一天
     *
     * @param pattern 格式
     * @return 格式等于自定义参数
     */
    public static String getLastMonthFirstDayOfPreviousYear(String pattern) {
        LocalDateTime localDateTime = LocalDateTime.now().minusYears(1L).withMonth(12).withDayOfMonth(1);
        return format(localDateTime2Date(localDateTime), pattern);
    }

    /**
     * 查询前一年最后一个月最后一天
     *
     * @return 默认格式 yyyy-MM-dd
     */
    public static String getLastMonthLastDayOfPreviousYear() {
        LocalDateTime localDateTime = LocalDateTime.now().minusYears(1L).with(TemporalAdjusters.lastDayOfYear());
        return format(localDateTime2Date(localDateTime), YEAR_MONTH_DAY);
    }

    /**
     * 查询前一年最后一个月最后一天
     *
     * @param pattern 格式
     * @return 格式等于自定义参数
     */
    public static String getLastMonthLastDayOfPreviousYear(String pattern) {
        LocalDateTime localDateTime = LocalDateTime.now().minusYears(1L).with(TemporalAdjusters.lastDayOfYear());
        return format(localDateTime2Date(localDateTime), pattern);
    }

    /**
     * 获取当前日期时间
     *
     * @return 默认格式 yyyy-MM-dd HH:mm:ss
     */
    public static String getCurrentDay() {
        LocalDateTime localDateTime = LocalDateTime.now();
        return format(localDateTime2Date(localDateTime), YEAR_MONTH_DAY_HOUR_MINUTE_SECONDS);
    }

    /**
     * 获取当前日期时间
     *
     * @param pattern 自定义格式
     * @return
     */
    public static String getCurrentDay(String pattern) {
        LocalDateTime localDateTime = LocalDateTime.now();
        return format(localDateTime2Date(localDateTime), pattern);
    }

    /**
     * 检查传入时间与系统相差时间 如果时间差在传入数值内则返回true
     *
     * @param startTime 格式：yyyy-MM-dd HH:mm:ss
     * @param minuteNum 分钟范围
     * @return boolean
     * @author jian Ye
     */
    public static boolean checkDifferTime(String startTime, int minuteNum) {
        LocalDateTime nowDateTime = LocalDateTime.now();
        LocalDateTime parseStartTime = LocalDateTime.parse(startTime, DateTimeFormatter.ofPattern(YEAR_MONTH_DAY_HOUR_MINUTE_SECONDS, Locale.CHINA));
        Duration duration = Duration.between(parseStartTime, nowDateTime);
        //相差的分钟数
        long minutes = duration.toMinutes();
        if (minutes <= minuteNum) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 计算两个日期之间相差天数
     *
     * @param begin 格式：yyyy-MM-dd
     * @param end   格式：yyyy-MM-dd
     * @return int
     * @author jian Ye
     */
    public static int getDateSpace(String begin, String end) {
        LocalDate parseBegin = LocalDate.parse(begin, DateTimeFormatter.ofPattern(YEAR_MONTH_DAY, Locale.CHINA));
        LocalDate parseEnd = LocalDate.parse(end, DateTimeFormatter.ofPattern(YEAR_MONTH_DAY, Locale.CHINA));
        return (int) (parseEnd.toEpochDay() - parseBegin.toEpochDay());
    }

    /**
     * 计算两个日期之间相差月数
     *
     * @param begin 格式：yyyy-MM
     * @param end   格式：yyyy-MM
     * @return int
     * @Author sj
     */
    public static int getDateMonthSpace(String begin, String end) {
        if (begin.equals(end)) {
            return 0;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(YEAR_MONTH);
        Calendar bef = Calendar.getInstance();
        Calendar aft = Calendar.getInstance();
        try {
            bef.setTime(sdf.parse(begin));
            aft.setTime(sdf.parse(end));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        int result = aft.get(Calendar.MONTH) - bef.get(Calendar.MONTH);
        int month = (aft.get(Calendar.YEAR) - bef.get(Calendar.YEAR)) * 12;
        return month + result;
    }



    /**
     * 判断当前时间大于等于开始时间且小于结束时间
     *
     * @param begin 格式：yyyy-MM-dd HH:mm:ss
     * @param end   格式：yyyy-MM-dd HH:mm:ss
     * @return boolean
     * @author jian Ye
     */
    public static boolean isTimeInterval(String begin, String end) {
        LocalDateTime nowDateTime = LocalDateTime.now();
        LocalDateTime startDate = LocalDateTime.parse(begin, DateTimeFormatter.ofPattern(YEAR_MONTH_DAY_HOUR_MINUTE_SECONDS, Locale.CHINA));
        LocalDateTime endDate = LocalDateTime.parse(end, DateTimeFormatter.ofPattern(YEAR_MONTH_DAY_HOUR_MINUTE_SECONDS, Locale.CHINA));
        if (Instant.from(nowDateTime.atZone(ZoneId.systemDefault())).toEpochMilli() >= Instant.from(startDate.atZone(ZoneId.systemDefault())).toEpochMilli() &&
                Instant.from(nowDateTime.atZone(ZoneId.systemDefault())).toEpochMilli() < Instant.from(endDate.atZone(ZoneId.systemDefault())).toEpochMilli()) {
            return true;
        }
        return false;
    }

    /**
     * 判断当前是否时间大于等于传入的时间
     *
     * @param begin 格式：yyyy-MM-dd HH:mm:ss
     * @return boolean
     * @author jian Ye
     */
    public static boolean isBeginTime(String begin) {
        LocalDateTime nowDateTime = LocalDateTime.now();
        LocalDateTime beginDate = LocalDateTime.parse(begin, DateTimeFormatter.ofPattern(YEAR_MONTH_DAY_HOUR_MINUTE_SECONDS, Locale.CHINA));
        if (Instant.from(nowDateTime.atZone(ZoneId.systemDefault())).toEpochMilli() >= Instant.from(beginDate.atZone(ZoneId.systemDefault())).toEpochMilli()) {
            return true;
        }
        return false;
    }

    /**
     * 判断当前是否时间小于传入的时间
     *
     * @param end 格式：yyyy-MM-dd HH:mm:ss
     * @return boolean
     * @author jian Ye
     */
    public static boolean isEndTime(String end) {
        LocalDateTime nowDateTime = LocalDateTime.now();
        LocalDateTime endDate = LocalDateTime.parse(end, DateTimeFormatter.ofPattern(YEAR_MONTH_DAY_HOUR_MINUTE_SECONDS, Locale.CHINA));
        if (Instant.from(nowDateTime.atZone(ZoneId.systemDefault())).toEpochMilli() < Instant.from(endDate.atZone(ZoneId.systemDefault())).toEpochMilli()) {
            return true;
        }
        return false;
    }

    /**
     * 当天剩余秒数
     */
    public static int getRemainingSeconds() {
        Calendar curDate = Calendar.getInstance();
        Calendar tomorrowDate = new GregorianCalendar(curDate
                .get(Calendar.YEAR), curDate.get(Calendar.MONTH), curDate
                .get(Calendar.DATE) + 1, 0, 0, 0);
        return (int) (tomorrowDate.getTimeInMillis() - curDate.getTimeInMillis()) / 1000;
    }

    /**
     * 日期字符串追加 00:00:00,
     *
     * @param dateStr 日期格式：yyyy-MM-dd
     * @return 返回yyyy-MM-dd HH:mm:ss
     */
    public static String appendDayStart(String dateStr) {
        if (!Objects.isEmpty(dateStr)) {
            return dateStr + " 00:00:00";
        }
        return null;
    }

    /**
     * 日期字符串追加 23:59:59
     *
     * @param dateStr 日期格式：yyyy-MM-dd
     * @return 返回yyyy-MM-dd HH:mm:ss
     */
    public static String appendDayEnd(String dateStr) {
        if (!Objects.isEmpty(dateStr)) {
            return dateStr + " 23:59:59";
        }
        return null;
    }

    /**
     * 比较第一个日期时间是否小于第二个日期
     *
     * @param firstDateTime  第一个日期
     * @param secondDateTime 第二个日期
     * @return true-小于;false-大于
     */
    public static boolean localDateIsBefore(LocalDateTime firstDateTime, LocalDateTime secondDateTime) {
        return firstDateTime.isBefore(secondDateTime);
    }


    /**
     * 比较第一个日期时间是否大于第二个日期
     *
     * @param firstDateTime  第一个日期
     * @param secondDateTime 第二个日期
     * @return true-大于;false-不大于
     */
    public static boolean localDateIsAfter(LocalDateTime firstDateTime, LocalDateTime secondDateTime) {
        return firstDateTime.isAfter(secondDateTime);
    }

    /**
     * 比较两个日期时间是否相等
     *
     * @param firstDateTime  第一个日期
     * @param secondDateTime 第二个日期
     * @return true-相等;false-不相等
     */
    public static boolean localDateIsEqual(LocalDateTime firstDateTime, LocalDateTime secondDateTime) {
        return firstDateTime.isEqual(secondDateTime);
    }

    /**
     * 日期时间比较
     *
     * @param date1
     * @param date2
     * @return
     */
    public static int dataTimeCompareTo(Date date1, Date date2) {
        //比较第一个日期时间是否小于第二个日期或第一个日期时间等于第二个日期时间
        if (localDateIsBefore(dateToLocalDateTime(date1), dateToLocalDateTime(date2)) || localDateIsEqual(dateToLocalDateTime(date1), dateToLocalDateTime(date2))) {
            return 1;
        }
        //比较第一个日期时间是否大于第二个日期或第一个日期时间等于第二个日期时间
        if (localDateIsAfter(dateToLocalDateTime(date1), dateToLocalDateTime(date2)) || localDateIsEqual(dateToLocalDateTime(date1), dateToLocalDateTime(date2))) {
            return 2;
        }
        return 0;
    }

    /**
     * 日期时间比较
     *
     * @param date1
     * @param date2
     * @return
     */
    public static int dataTimeCompareTod(Date date1, Date date2) {
        //比较第一个日期时间等于第二个日期时间
        if (localDateIsEqual(dateToLocalDateTime(date1), dateToLocalDateTime(date2))) {
            return 0;
        }
        //比较第一个日期时间是否小于第二个日期
        if (localDateIsBefore(dateToLocalDateTime(date1), dateToLocalDateTime(date2))) {
            return 1;
        }
        //比较第一个日期时间是否大于第二个日期
        if (localDateIsAfter(dateToLocalDateTime(date1), dateToLocalDateTime(date2))) {
            return 2;
        }
        return 0;
    }





    /**
     * 获取本月的第一天
     *
     * @return 如：2021-08-01
     */
    public static String getFirstDayOfThisMonth() {
        return getCurrentLocalDate().with(TemporalAdjusters.firstDayOfMonth()).format(DateTimeFormatter.ofPattern(YEAR_MONTH_DAY));
    }


    /**
     * 获取本月的最后一天
     *
     * @return 如：2021-08-31
     */
    public static String getLastDayOfThisMonth() {
        return getCurrentLocalDate().with(TemporalAdjusters.lastDayOfMonth()).format(DateTimeFormatter.ofPattern(YEAR_MONTH_DAY));
    }


    /**
     * 获取下个月
     *
     * @param month 年月(如：2021-08)
     * @return 返回下个月的年月（如：2021-09）
     */
    public static String getNextMonth(String month) {
        YearMonth yearMonth = YearMonth.parse(month);
        return yearMonth.minus(-1, ChronoUnit.MONTHS).toString();

    }


    /**
     * 获取东八时区
     */
    public static TimeZone getTimeZone8() {
        return TimeZone.getTimeZone("GMT+8");
    }


    /**
     * 判断是否周六或周日
     *
     * @param date
     * @return 是true； 否false
     */
    public static boolean isWeekend(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY || cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY
                || cal.get(Calendar.DAY_OF_YEAR) == Calendar.FRIDAY || cal.get(Calendar.DAY_OF_YEAR) == Calendar.SUNDAY;
    }



}